Language/OS - Multiplatform Resource Library/LANGUAGE OS.iso/et/et3_0-a1.lha/et3/src/Converter.C

C/C++ Source or Header | 1992-06-29 | 5KB | 247 lines

#ifdef __GNUG__
#pragma implementation
#endif

#include "Converter.h"

#include "Class.h"
#include "String.h"
#include "Data.h"
#include "CLib.h"
#include "OrdColl.h"
#include "ClassManager.h"

#include "CollView.h"
#include "TextItem.h"
#include "BorderItems.h"
#include "Box.h"
#include "Scroller.h"
#include "Expander.h"
#include "Dialog.h"
#include "Buttons.h"

//---- ConverterDialog ---------------------------------------------------------

class ConverterDialog : public Dialog {
public:
    MetaDef(ConverterDialog);
    ConverterDialog();
    ~ConverterDialog();
    Converter *ShowInWindow(SeqCollection *list);
    VObject *DoMakeContent();
    void DoSetup();
    void Control(int id, int p, void *v);
private:
    CollectionView *collView;
    SeqCollection *converterList;
};

NewMetaImpl0(ConverterDialog,Dialog);

ConverterDialog::ConverterDialog() : Dialog("Converter")
{
}

ConverterDialog::~ConverterDialog()
{
    SafeDelete(collView);
}

Converter *ConverterDialog::ShowInWindow(SeqCollection *list)
{
    converterList= list;

    OrdCollection *col= new OrdCollection;
    Iter next(converterList);
    Converter *cv;

    while (cv= (Converter*) next())
    col->Add(new TextItem(cv->AsString()));

    collView= new CollectionView(this, col, eCVDontStuckToBorder);
    collView->SetMinExtent(Point(100, 0));

    Port *old= GrGetPort();
    Dialog::Show();
    if (old)
    GrSetPort(old);

    Rectangle r= collView->GetSelection();
    if (r.IsNotEmpty())
    return (Converter*) converterList->At(r.origin.y);
    return 0;
}

VObject *ConverterDialog::DoMakeContent()
{
    return
    new Matte(
        new Expander(cIdNone, eVert, 20,
        new Scroller(collView, Point(150, cAutoSize)),
        new HBox(10, (VObjAlign)(eVObjVBase|eVObjHEqual|eVObjHExpand),
            new ActionButton(cIdOk, "Convert", TRUE),
            new ActionButton(cIdCancel, "Cancel"),
            0
        ),
        0
        )
    );
}

void ConverterDialog::DoSetup()
{
    EnableItem(cIdOk, !collView->GetSelection().IsEmpty());
}

void ConverterDialog::Control(int id, int p, void *v)
{
    if (p == cPartCollDoubleSelect) {
    Dialog::Control(cIdOk, cPartAction, v);
    } else
    Dialog::Control(id, p, v);
}

//---- Converter ---------------------------------------------------------------

ONEXIT(Converter)
{
    Converter::CleanUp();
}

NewMetaImpl(Converter,Object, (TP(filters)));

OrdCollection *Converter::filters;

Converter::Converter()
{
}

void Converter::CleanUp()
{
    if (filters) {
    filters->FreeAll();
    SafeDelete(filters);
    }
}

Converter *Converter::SelectConverter(OrdCollection *list)
{
    Converter *cv= 0;
    if (list->Size() > 1) {
    ConverterDialog *dia= new ConverterDialog;
    cv= dia->ShowInWindow(list);
    gSystem->AddCleanupObject(dia);
    } else if (list->Size() == 1)
    cv= (Converter*) list->At(0);
    return cv;
}

Converter *Converter::FindConverter(Data *data, Class *want, OrdCollection *l)
{
    if (filters == 0) {
    Iter next(gClassManager->Iterator());
    Class *cla;

    filters= new OrdCollection;
    while (cla= (Class*)next())
        if (cla->isKindOf(Meta(Converter)))
        filters->Add(cla->Proto()->New());
    }

    Iter next(filters);
    register Converter *filter;

    while (filter= (Converter*) next())
    if (filter->CanConvert(data, want)) {
        if (gDebug)
        fprintf(stderr, "Converter::FindConverter: %s\n", filter->AsString());
        if (l == 0)
        return filter;
        if (l->FindPtr(filter) == 0)
        l->Add(filter);
    }
    if (l && l->Size() > 0)
    return (Converter*)l->At(0);
    if (gDebug)
    fprintf(stderr, "Converter::FindConverter: no filter found\n");
    return 0;
}

bool Converter::CanConvert(Data*, Class*)
{
    return FALSE;
}

Object *Converter::Convert(Data*, Class*)
{
    return 0;
}

Object *Converter::AsObject(Data *data, Class *want)
{
    return Convert(data, want);
}

//---- OIOConverter ------------------------------------------------------------

class OIOConverter : public Converter {
public:
    MetaDef(OIOConverter);
    OIOConverter() : Converter()
    { }
    char *AsString()
    { return "ET++ Object Input/Output"; }
    Object *Convert(Data *data, Class *want);
    bool CanConvert(Data *data, Class *want);
};

NewMetaImpl0(OIOConverter, Converter);

bool OIOConverter::CanConvert(Data *data, Class *want)
{
    if (!data->IsETFormat())
    return FALSE;
    if (gDebug)
    fprintf(stderr, "OIOConverter::CanConvert: is:%s want:%s\n",
                    data->Type().AsString(), want->Name());
    if (data->GetClassType() == 0) {
    if (data->Type() == Symbol(want->Name()))
        return TRUE;
    if (data->IsETFormat()) {
        Object *op= Convert(data, want);
        if (op == 0)
        return FALSE;
        SafeDelete(op);
        return TRUE;
    }
    return FALSE;
    }
    //fprintf(stderr, "%s\n", data->GetClassType()->Name());
    //if (!data->IsETFormat())
    //    return FALSE;
    //fprintf(stderr, "oops\n");
    return data->GetClassType()->isKindOf(want);
}

Object *OIOConverter::Convert(Data *data, Class *want)
{
    char c;
    IStream ois(data->GetStreamBufForReading(), 0, TRUE);
    Object *op= 0;

    ois.get(c);
    if (c == '@') {
    while (ois.get(c))
        if (c == '\n')
        break;
    } else
    ois.putback(c);

    ois >> op;
    if (op && op->IsA()->isKindOf(want))
    return op;
    SafeDelete(op);
    return 0;
}